package services

import (
	"gin-quickstart/internal/models"
	"gorm.io/gorm"
)

// ProductService 产品服务接口
type ProductService interface {
	// 创建SPU产品
	CreateSPU(spu *models.SPU) error
	// 根据ID获取SPU产品
	GetSPUByID(id uint) (*models.SPU, error)
	// 获取所有SPU产品
	GetAllSPUs() ([]*models.SPU, error)
	// 更新SPU产品
	UpdateSPU(spu *models.SPU) error
	// 删除SPU产品
	DeleteSPU(id uint) error
	
	// SKU相关操作
	CreateSKU(sku *models.SKU) error
	GetSKUsBySPUID(spuID uint) ([]*models.SKU, error)
	UpdateSKU(sku *models.SKU) error
}

// ProductServiceImpl 产品服务实现
type ProductServiceImpl struct {
	DB *gorm.DB
}

// NewProductService 创建产品服务实例
func NewProductService(db *gorm.DB) ProductService {
	return &ProductServiceImpl{DB: db}
}

// CreateSPU 创建SPU产品
func (s *ProductServiceImpl) CreateSPU(spu *models.SPU) error {
	// 业务逻辑验证
	if spu.SPUName == "" {
		return gorm.ErrInvalidData
	}
	
	// 检查分类和品牌是否存在
	var category models.BCategory
	if err := s.DB.First(&category, spu.BCategoryID).Error; err != nil {
		return err
	}
	
	var brand models.Brand
	if err := s.DB.First(&brand, spu.BrandID).Error; err != nil {
		return err
	}
	
	// 执行保存操作
	return s.DB.Create(spu).Error
}

// GetSPUByID 根据ID获取SPU产品
func (s *ProductServiceImpl) GetSPUByID(id uint) (*models.SPU, error) {
	var spu models.SPU
	err := s.DB.Preload("BCategory").Preload("Brand").First(&spu, id).Error
	if err != nil {
		return nil, err
	}
	return &spu, nil
}

// GetAllSPUs 获取所有SPU产品
func (s *ProductServiceImpl) GetAllSPUs() ([]*models.SPU, error) {
	var spus []*models.SPU
	err := s.DB.Preload("BCategory").Preload("Brand").Find(&spus).Error
	if err != nil {
		return nil, err
	}
	return spus, nil
}

// UpdateSPU 更新SPU产品
func (s *ProductServiceImpl) UpdateSPU(spu *models.SPU) error {
	// 业务逻辑验证
	if spu.SPUID == 0 {
		return gorm.ErrInvalidData
	}
	
	return s.DB.Save(spu).Error
}

// DeleteSPU 删除SPU产品
func (s *ProductServiceImpl) DeleteSPU(id uint) error {
	// 开始事务
	tx := s.DB.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()
	
	// 检查是否存在关联的SKU
	var skuCount int64
	if err := tx.Model(&models.SKU{}).Where("SPU_ID = ?", id).Count(&skuCount).Error; err != nil {
		tx.Rollback()
		return err
	}
	
	if skuCount > 0 {
		tx.Rollback()
		return gorm.ErrForeignKeyViolated
	}
	
	// 删除SPU
	if err := tx.Delete(&models.SPU{}, id).Error; err != nil {
		tx.Rollback()
		return err
	}
	
	return tx.Commit().Error
}

// CreateSKU 创建SKU
func (s *ProductServiceImpl) CreateSKU(sku *models.SKU) error {
	// 检查SPU是否存在
	var spu models.SPU
	if err := s.DB.First(&spu, sku.SPUID).Error; err != nil {
		return err
	}
	
	// 业务逻辑验证
	if sku.Price <= 0 {
		return gorm.ErrInvalidData
	}
	
	return s.DB.Create(sku).Error
}

// GetSKUsBySPUID 根据SPU ID获取所有SKU
func (s *ProductServiceImpl) GetSKUsBySPUID(spuID uint) ([]*models.SKU, error) {
	var skus []*models.SKU
	err := s.DB.Where("SPU_ID = ?", spuID).Find(&skus).Error
	if err != nil {
		return nil, err
	}
	return skus, nil
}

// UpdateSKU 更新SKU
func (s *ProductServiceImpl) UpdateSKU(sku *models.SKU) error {
	if sku.SKUID == 0 {
		return gorm.ErrInvalidData
	}
	return s.DB.Save(sku).Error
}
